"""
智能化提示词系统 - 大幅提升AI响应效率
根据需求类型、复杂度、场景自动选择最优提示词模板
"""

import re
from typing import Dict, List, Tuple, Optional
from enum import Enum


class PromptType(Enum):
    """提示词类型枚举"""
    ULTRA_FAST = "ultra_fast"      # 超快速模式 - 30秒内响应
    FAST = "fast"                  # 快速模式 - 60秒内响应
    BALANCED = "balanced"          # 平衡模式 - 90秒内响应
    QUALITY = "quality"            # 质量模式 - 120秒内响应


class RequirementType(Enum):
    """需求类型枚举"""
    SIMPLE_CRUD = "simple_crud"    # 简单增删改查
    LOGIN_AUTH = "login_auth"      # 登录认证类
    FORM_VALIDATION = "form_validation"  # 表单验证类
    WORKFLOW = "workflow"          # 工作流程类
    COMPLEX_BUSINESS = "complex_business"  # 复杂业务类
    API_INTERFACE = "api_interface"  # 接口类
    UNKNOWN = "unknown"            # 未知类型


def get_ultra_fast_prompt() -> str:
    """超快速提示词 - 最精简版本"""
    return """测试工程师。生成JSON测试用例。

格式：{"test_cases":[{"id":"TC001","title":"场景","steps":[{"step_number":1,"description":"操作","expected_result":"结果"}],"priority":"P2"}]}

生成3-6个核心用例，包含正常+异常场景，优先级P1-P3合理分配。只返回JSON。"""


def get_fast_prompt() -> str:
    """快速提示词 - 简化版本"""
    return """专业测试工程师。生成测试用例JSON。

要求：
- 生成5-8个用例，优先级合理分配
- 包含正常和异常场景
- 步骤具体可操作
- 结果明确详细
- 优先级分配：P1(核心功能30%) P2(重要功能50%) P3(辅助功能20%)

JSON格式：
{
  "test_cases": [
    {
      "id": "TC001",
      "title": "功能-场景",
      "preconditions": "前置条件",
      "steps": [{"step_number": 1, "description": "具体操作", "expected_result": "明确结果"}],
      "priority": "P2"
    }
  ]
}

只返回JSON，无其他内容。"""


def get_balanced_prompt() -> str:
    """平衡提示词 - 标准版本"""
    return """资深测试工程师。根据需求生成高质量测试用例JSON。

核心要求：
1. 生成8-12个测试用例，优先级分布合理
2. 覆盖正常流程（1-2个）+ 异常流程（多个）
3. 包含边界值和错误处理测试
4. 步骤描述具体可操作，包含界面元素和测试数据
5. 预期结果详细明确，避免模糊词汇
6. 优先级分配原则：
   - P1: 核心主流程、关键业务功能 (25%)
   - P2: 重要功能、常用场景 (45%)
   - P3: 辅助功能、边界条件 (25%)
   - P4: 非核心功能、极端场景 (5%)

JSON结构：
{
  "test_cases": [
    {
      "id": "TC001",
      "title": "功能模块-测试场景",
      "preconditions": "具体前置条件",
      "steps": [
        {
          "step_number": 1,
          "description": "在XX输入框输入：具体数据",
          "expected_result": "界面显示XX，数据变为XX，系统响应XX"
        }
      ],
      "priority": "P2",
      "category": "功能测试"
    }
  ]
}

严格按JSON格式返回，确保优先级分布合理。"""


def get_optimized_user_prompt(requirement: str) -> str:
    """获取优化的用户提示词"""
    # 精简需求描述，保留关键信息
    simplified_requirement = _simplify_requirement(requirement)

    return f"""需求：{simplified_requirement}

生成测试用例JSON，包含：
- 正常流程用例
- 异常场景用例
- 边界值测试用例

直接返回JSON："""


def _simplify_requirement(requirement: str) -> str:
    """简化需求描述，保留关键信息"""
    if len(requirement) <= 500:
        return requirement

    # 提取关键信息
    lines = requirement.split('\n')
    key_lines = []

    for line in lines:
        line = line.strip()
        if not line:
            continue

        # 保留包含关键词的行
        key_words = ['功能', '用户', '系统', '输入', '输出',
                     '验证', '登录', '注册', '查询', '添加', '删除', '修改']
        if any(word in line for word in key_words):
            key_lines.append(line)

        # 限制长度
        if len('\n'.join(key_lines)) > 400:
            break

    simplified = '\n'.join(key_lines)

    # 如果简化后太短，保留原始需求的前400字符
    if len(simplified) < 100:
        simplified = requirement[:400] + \
            "..." if len(requirement) > 400 else requirement

    return simplified


def get_concurrent_system_prompt() -> str:
    """获取并发处理专用的系统提示词"""
    return """专业测试工程师。生成模块测试用例。

输出JSON格式：
{
  "test_cases": [
    {
      "id": "TC001",
      "title": "模块功能-测试场景",
      "preconditions": "前置条件",
      "steps": [{"step_number": 1, "description": "操作", "expected_result": "结果"}],
      "priority": "P2",
      "category": "功能测试"
    }
  ]
}

要求：
- 针对单个模块生成3-8个用例
- 覆盖正常和异常场景，优先级P1-P3合理分配
- 只返回JSON，无其他内容"""


def get_batch_system_prompt() -> str:
    """获取批量处理专用的系统提示词"""
    return """测试工程师。批量生成测试用例。

JSON格式：
{
  "test_cases": [
    {
      "id": "TC001",
      "title": "功能-场景",
      "preconditions": "前置条件",
      "steps": [{"step_number": 1, "description": "步骤", "expected_result": "结果"}],
      "priority": "P2"
    }
  ]
}

生成10-20个用例，覆盖所有功能点，优先级P1(25%) P2(45%) P3(25%) P4(5%)合理分配。只返回JSON。"""


def get_simple_system_prompt() -> str:
    """获取简单需求专用的系统提示词"""
    return """测试工程师。生成测试用例JSON。

格式：
{
  "test_cases": [
    {
      "id": "TC001",
      "title": "测试场景",
      "preconditions": "前置条件",
      "steps": [{"step_number": 1, "description": "操作", "expected_result": "结果"}],
      "priority": "P2"
    }
  ]
}

生成3-8个用例。只返回JSON。"""


def get_optimized_system_prompt() -> str:
    """获取优化的系统提示词 - 包含详细的优先级分配指导"""
    return """资深测试工程师。根据需求生成高质量测试用例JSON。

核心要求：
1. 生成10-15个测试用例，覆盖不同优先级
2. 优先级分配规则：
   - P1(高优先级): 核心功能、主流程、关键业务场景 (20-30%)
   - P2(中优先级): 重要功能、常用场景、基本验证 (40-50%)
   - P3(普通优先级): 辅助功能、边界条件、异常处理 (20-30%)
   - P4(低优先级): 非核心功能、极端场景、兼容性测试 (5-10%)
3. 包含正常流程、异常流程、边界值测试
4. 步骤描述具体可操作，包含界面元素和测试数据
5. 预期结果详细明确，避免模糊词汇

JSON结构：
{
  "test_cases": [
    {
      "id": "TC001",
      "title": "功能模块-测试场景",
      "preconditions": "具体前置条件",
      "steps": [
        {
          "step_number": 1,
          "description": "在XX输入框输入：具体数据",
          "expected_result": "界面显示XX，数据变为XX，系统响应XX"
        }
      ],
      "priority": "P1",
      "category": "功能测试"
    }
  ]
}

严格按JSON格式返回，确保优先级分布合理。"""


def select_optimal_prompt(requirement_length: int, is_concurrent: bool = False, is_batch: bool = False) -> str:
    """根据需求复杂度选择最优提示词"""

    if is_concurrent:
        return get_concurrent_system_prompt()

    if is_batch:
        return get_batch_system_prompt()

    if requirement_length <= 200:
        return get_simple_system_prompt()
    elif requirement_length <= 1000:
        return get_optimized_system_prompt()
    else:
        return get_batch_system_prompt()


def create_optimized_messages(requirement: str, is_concurrent: bool = False, is_batch: bool = False) -> list:
    """创建优化的消息列表"""
    requirement_length = len(requirement)

    system_prompt = select_optimal_prompt(
        requirement_length, is_concurrent, is_batch)
    user_prompt = get_optimized_user_prompt(requirement)

    return [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_prompt}
    ]


def get_performance_optimized_config(requirement_length: int) -> dict:
    """获取性能优化的配置"""

    if requirement_length <= 200:
        # 简单需求 - 快速响应
        return {
            "temperature": 0.1,
            "max_tokens": 1000,
            "timeout_multiplier": 0.7
        }
    elif requirement_length <= 500:
        # 中等需求 - 平衡质量和速度
        return {
            "temperature": 0.2,
            "max_tokens": 1500,
            "timeout_multiplier": 0.8
        }
    elif requirement_length <= 1000:
        # 复杂需求 - 保证质量
        return {
            "temperature": 0.3,
            "max_tokens": 2000,
            "timeout_multiplier": 1.0
        }
    else:
        # 超复杂需求 - 分批处理
        return {
            "temperature": 0.2,
            "max_tokens": 2500,
            "timeout_multiplier": 1.2
        }


class PromptOptimizer:
    """提示词优化器"""

    @staticmethod
    def optimize_for_speed(requirement: str) -> tuple:
        """为速度优化提示词"""
        simplified_req = _simplify_requirement(requirement)

        system_prompt = """测试工程师。快速生成测试用例JSON。

格式：{"test_cases":[{"id":"TC001","title":"场景","steps":[{"step_number":1,"description":"步骤","expected_result":"结果"}],"priority":"P2"}]}

生成3-6个核心用例，优先级P1-P3合理分配。只返回JSON。"""

        user_prompt = f"需求：{simplified_req}\n\n生成测试用例JSON："

        return system_prompt, user_prompt

    @staticmethod
    def optimize_for_quality(requirement: str) -> tuple:
        """为质量优化提示词"""
        system_prompt = get_optimized_system_prompt()
        user_prompt = get_optimized_user_prompt(requirement)

        return system_prompt, user_prompt

    @staticmethod
    def optimize_for_batch(requirements: list) -> tuple:
        """为批量处理优化提示词"""
        combined_req = "\n\n".join(requirements[:3])  # 限制批量大小

        system_prompt = get_batch_system_prompt()
        user_prompt = f"批量需求：\n{combined_req}\n\n生成测试用例JSON："

        return system_prompt, user_prompt


def estimate_response_time(requirement_length: int, model_type: str = "default") -> float:
    """估算响应时间（秒）"""

    # 基础时间（根据模型类型）
    base_times = {
        "deepseek": 15,    # DeepSeek较快
        "doubao": 20,      # 豆包中等
        "openai": 25,      # OpenAI较慢但质量高
        "local": 30,       # 本地模型最慢
        "default": 20
    }

    base_time = base_times.get(model_type, 20)

    # 根据需求长度调整
    if requirement_length <= 200:
        return base_time * 0.6
    elif requirement_length <= 500:
        return base_time * 0.8
    elif requirement_length <= 1000:
        return base_time * 1.0
    else:
        return base_time * 1.3


def get_retry_strategy(attempt: int, error_type: str = "general") -> dict:
    """获取重试策略"""

    strategies = {
        "timeout": {
            "delay": min(5 * attempt, 15),
            "timeout_multiplier": 1.5 + (attempt * 0.3),
            "reduce_tokens": True
        },
        "rate_limit": {
            "delay": min(10 * attempt, 30),
            "timeout_multiplier": 1.0,
            "reduce_tokens": False
        },
        "general": {
            "delay": min(3 * attempt, 10),
            "timeout_multiplier": 1.2 + (attempt * 0.2),
            "reduce_tokens": False
        }
    }

    return strategies.get(error_type, strategies["general"])
